# -*- coding: utf-8 -*-
"""
金桔王Langgraph工作流图
整合意图识别、权限校验、业务逻辑处理等节点，构建完整的工作流
"""
import traceback
from typing import Dict, Any, Literal
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from common.log import logger
from pydantic_models import WXWorkIn
from .workflow_utils import WorkflowState, create_workflow_state
from .intention_node import intention_recognition_node
from .permission_node import permission_validation_node
from .business_logic_node import business_logic_node
from common.enum_types import ActionType


class KQKWorkflow:
    """金桔王工作流管理器"""
    
    def __init__(self):
        """初始化工作流"""
        self.graph = self._build_graph()
    
    def _build_graph(self) -> StateGraph:
        """构建Langgraph工作流图"""
        try:
            # 创建状态图
            workflow = StateGraph(WorkflowState)
            
            # 添加节点
            workflow.add_node("intention_recognition", intention_recognition_node)
            workflow.add_node("permission_validation", permission_validation_node)
            workflow.add_node("business_logic", business_logic_node)
            
            # 设置入口点
            workflow.set_entry_point("intention_recognition")
            
            # 添加边（工作流路径）
            workflow.add_edge("intention_recognition", "permission_validation")
            
            # 权限校验后的条件分支
            workflow.add_conditional_edges(
                "permission_validation",
                self._should_continue_to_business_logic,
                {
                    "continue": "business_logic",
                    "end": END
                }
            )
            
            # 业务逻辑处理完成后结束
            workflow.add_edge("business_logic", END)
            
            # 编译图
            compiled_graph = workflow.compile()            
            return compiled_graph
            
        except Exception as e:
            logger.error(f"[KQK工作流] ❌ 构建工作流图失败: {e} - {traceback.format_exc()}")
            raise
    
    def _should_continue_to_business_logic(self, state: WorkflowState) -> Literal["continue", "end"]:
        """
        判断是否继续到业务逻辑处理
        
        Args:
            state: 工作流状态
            
        Returns:
            "continue" 或 "end"
        """
        try:
            # 如果权限不足，直接结束
            if not state.get("permission_granted", False):
                logger.info(f"[KQK工作流] 🚫 权限不足，工作流结束")
                return "end"
            
            # 如果有错误消息，直接结束
            if state.get("error_message"):
                logger.info(f"[KQK工作流] ❌ 存在错误，工作流结束")
                return "end"
            
            # 默认继续业务逻辑处理
            logger.debug(f"[KQK工作流] ✅ 权限验证通过，继续业务逻辑处理")
            return "continue"
            
        except Exception as e:
            logger.error(f"[KQK工作流] ❌ 判断工作流路径异常: {e} - {traceback.format_exc()}")
            return "end"
    
    async def process_message(self, wx_msg: WXWorkIn) -> str:
        """
        异步处理消息
        
        Args:
            wx_msg: 企业微信消息
            
        Returns:
            处理结果
        """
        try:
            logger.info(f"[KQK工作流] 📨 开始异步处理消息")
            
            # 创建初始状态
            initial_state = create_workflow_state(wx_msg)
            
            # 执行工作流
            result = await self.graph.ainvoke(initial_state)
            
            # 提取最终响应
            final_response = result.get("final_response", "处理完成，但没有响应内容")
            
            logger.info(f"[KQK工作流] ✅ 异步消息处理完成")
            return final_response
            
        except Exception as e:
            logger.error(f"[KQK工作流] ❌ 异步处理消息异常: {e} - {traceback.format_exc()}")
            return f"系统处理异常: {str(e)}"
    
    def process_message_sync(self, wx_msg: WXWorkIn, chat_handler=None) -> str:
        """
        同步处理消息
        
        Args:
            wx_msg: 企业微信消息
            chat_handler: ChatHandler实例，用于记录workflow处理流程
            
        Returns:
            处理结果
        """
        try:
            # 创建初始状态，传入chat_handler
            initial_state = create_workflow_state(wx_msg, chat_handler)
            
            # 执行工作流
            result = self.graph.invoke(initial_state)
            
            # 提取最终响应
            final_response = result.get("final_response", "处理完成，但没有响应内容")
            
            return final_response
            
        except Exception as e:
            error_msg = f"工作流处理失败: {e} - {traceback.format_exc()}"
            logger.error(f"[🔄工作流] {error_msg}")
            
            # 记录工作流错误
            if chat_handler:
                chat_handler.add_action("WORKFLOW_ERROR")
                chat_handler.set_note(error_msg)
            
            return f"系统处理异常: {str(e)}"
    
    def process_message_sync_with_db(self, wx_msg: WXWorkIn, chat_handler=None, db=None) -> str:
        """
        同步处理消息（支持数据库会话依赖注入）
        
        Args:
            wx_msg: 企业微信消息
            chat_handler: ChatHandler实例，用于记录workflow处理流程
            db: 数据库会话（通过依赖注入）
            
        Returns:
            处理结果
        """
        try:
            # 使用依赖注入的数据库会话创建初始状态
            if db:
                from kqk_workflow.workflow_utils import create_workflow_state_with_db
                initial_state = create_workflow_state_with_db(wx_msg, db, chat_handler)
            else:
                # 降级到原有方式
                initial_state = create_workflow_state(wx_msg, chat_handler)
            
            # 执行工作流
            result = self.graph.invoke(initial_state)
            
            # 提取最终响应
            final_response = result.get("final_response", "处理完成，但没有响应内容")
            
            return final_response
            
        except Exception as e:
            error_msg = f"工作流处理失败: {e} - {traceback.format_exc()}"
            logger.error(f"[🔄工作流] {error_msg}")
            
            # 记录工作流错误
            if chat_handler:
                chat_handler.add_action("WORKFLOW_ERROR")
                chat_handler.set_note(error_msg)
            
            return f"系统处理异常: {str(e)}"


# 全局工作流实例
_kqk_workflow_instance = None


def get_kqk_workflow() -> KQKWorkflow:
    """
    获取金桔王工作流实例（单例模式）
    
    Returns:
        KQKWorkflow实例
    """
    global _kqk_workflow_instance
    
    if _kqk_workflow_instance is None:
        _kqk_workflow_instance = KQKWorkflow()
        # logger.info(f"[KQK工作流] 🆕 创建新的工作流实例")
    
    return _kqk_workflow_instance


def reset_workflow_instances():
    """重置工作流实例（用于测试或重新初始化）"""
    global _kqk_workflow_instance
    _kqk_workflow_instance = None
    logger.info(f"[KQK工作流] 🔄 工作流实例已重置")